/*******************************************************************************
* Copyright (c) 2002, 2016 GEBIT Gesellschaft fuer EDV-Beratung
* und Informatik-Technologien mbH,
* Berlin, Duesseldorf, Frankfurt (Germany) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* GEBIT Gesellschaft fuer EDV-Beratung und Informatik-Technologien mbH - initial API and implementation
* IBM Corporation - bug fixes
* John-Mason P. Shackelford (john-mason.shackelford@pearson.com) - bug 49380, bug 34548, bug 53547
*******************************************************************************/
package org.eclipse.ant.internal.ui.editor.outline;
import java.util.List;
import org.eclipse.ant.internal.ui.AntUIPlugin;
import org.eclipse.ant.internal.ui.IAntUIConstants;
import org.eclipse.ant.internal.ui.IAntUIPreferenceConstants;
import org.eclipse.ant.internal.ui.editor.AntEditor;
import org.eclipse.ant.internal.ui.editor.actions.TogglePresentationAction;
import org.eclipse.ant.internal.ui.model.AntElementNode;
import org.eclipse.ant.internal.ui.model.AntImportNode;
import org.eclipse.ant.internal.ui.model.AntModel;
import org.eclipse.ant.internal.ui.model.AntModelChangeEvent;
import org.eclipse.ant.internal.ui.model.AntModelContentProvider;
import org.eclipse.ant.internal.ui.model.AntModelCore;
import org.eclipse.ant.internal.ui.model.AntModelLabelProvider;
import org.eclipse.ant.internal.ui.model.AntProjectNode;
import org.eclipse.ant.internal.ui.model.AntPropertyNode;
import org.eclipse.ant.internal.ui.model.AntTargetNode;
import org.eclipse.ant.internal.ui.model.AntTaskNode;
import org.eclipse.ant.internal.ui.model.IAntModel;
import org.eclipse.ant.internal.ui.model.IAntModelListener;
import org.eclipse.ant.internal.ui.views.actions.AntOpenWithMenu;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.ListenerList;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerComparator;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.ui.IWorkbenchActionConstants;
import org.eclipse.ui.part.IPageSite;
import org.eclipse.ui.part.IShowInSource;
import org.eclipse.ui.part.ShowInContext;
import org.eclipse.ui.texteditor.ITextEditorActionDefinitionIds;
import org.eclipse.ui.views.contentoutline.ContentOutlinePage;
/**
* Content outline page for the Ant Editor.
*/
public class AntEditorContentOutlinePage extends ContentOutlinePage implements IShowInSource, IAdaptable {
private static final int EXPAND_TO_LEVEL = 2;
private Menu fMenu;
private AntOpenWithMenu fOpenWithMenu;
private IAntModelListener fListener;
private IAntModel fModel;
private AntModelCore fCore;
private ListenerList<ISelectionChangedListener> fPostSelectionChangedListeners = new ListenerList<>();
private boolean fIsModelEmpty = true;
private boolean fFilterInternalTargets;
private boolean fFilterImportedElements;
private boolean fFilterProperties;
private boolean fFilterTopLevel;
private boolean fSort;
private ViewerComparator fComparator;
private AntEditor fEditor;
private TogglePresentationAction fTogglePresentation;
/**
* A viewer filter for the Ant Content Outline
*/
private class AntOutlineFilter extends ViewerFilter {
@Override
public boolean select(Viewer viewer, Object parentElement, Object element) {
if (element instanceof AntElementNode) {
AntElementNode node = (AntElementNode) element;
if (fFilterTopLevel && (node instanceof AntTaskNode && parentElement instanceof AntProjectNode)) {
return false;
}
if (fFilterImportedElements && (node.getImportNode() != null || node.isExternal())) {
if (node instanceof AntTargetNode && ((AntTargetNode) node).isDefaultTarget()) {
return true;
}
return false;
}
if (fFilterInternalTargets && node instanceof AntTargetNode) {
return !((AntTargetNode) node).isInternal();
}
if (fFilterProperties && node instanceof AntPropertyNode) {
return false;
}
if (!node.isStructuralNode()) {
return false;
}
}
return true;
}
}
private class AntOutlineComparator extends ViewerComparator {
/*
* (non-Javadoc)
*
* @see org.eclipse.jface.viewers.ViewerComparator#compare(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object)
*/
@Override
public int compare(Viewer viewer, Object e1, Object e2) {
if (!(e1 instanceof AntElementNode && e2 instanceof AntElementNode)) {
return super.compare(viewer, e1, e2);
}
String name1 = ((AntElementNode) e1).getLabel();
String name2 = ((AntElementNode) e2).getLabel();
return getComparator().compare(name1, name2);
}
}
/**
* Sets whether internal targets should be filtered out of the outline.
*
* @param filter
* whether or not internal targets should be filtered out
*/
protected void setFilterInternalTargets(boolean filter) {
fFilterInternalTargets = filter;
setFilter(filter, IAntUIPreferenceConstants.ANTEDITOR_FILTER_INTERNAL_TARGETS);
}
/**
* Sets whether imported elements should be filtered out of the outline.
*
* @param filter
* whether or not imported elements should be filtered out
*/
protected void setFilterImportedElements(boolean filter) {
fFilterImportedElements = filter;
setFilter(filter, IAntUIPreferenceConstants.ANTEDITOR_FILTER_IMPORTED_ELEMENTS);
}
private void setFilter(boolean filter, String name) {
if (name != null) {
AntUIPlugin.getDefault().getPreferenceStore().setValue(name, filter);
}
// filter has been changed
getTreeViewer().refresh();
}
/**
* Sets whether properties should be filtered out of the outline.
*
* @param filter
* whether or not properties should be filtered out
*/
protected void setFilterProperties(boolean filter) {
fFilterProperties = filter;
setFilter(filter, IAntUIPreferenceConstants.ANTEDITOR_FILTER_PROPERTIES);
}
/**
* Sets whether internal targets should be filtered out of the outline.
*
* @param filter
* whether or not internal targets should be filtered out
*/
protected void setFilterTopLevel(boolean filter) {
fFilterTopLevel = filter;
setFilter(filter, IAntUIPreferenceConstants.ANTEDITOR_FILTER_TOP_LEVEL);
}
/**
* Returns whether internal targets are currently being filtered out of the outline.
*
* @return whether or not internal targets are being filtered out
*/
protected boolean filterInternalTargets() {
return fFilterInternalTargets;
}
/**
* Returns whether imported elements are currently being filtered out of the outline.
*
* @return whether or not imported elements are being filtered out
*/
protected boolean filterImportedElements() {
return fFilterImportedElements;
}
/**
* Returns whether properties are currently being filtered out of the outline.
*
* @return whether or not properties are being filtered out
*/
protected boolean filterProperties() {
return fFilterProperties;
}
/**
* Returns whether top level tasks/types are currently being filtered out of the outline.
*
* @return whether or not top level tasks/types are being filtered out
*/
protected boolean filterTopLevel() {
return fFilterTopLevel;
}
/**
* Sets whether elements should be sorted in the outline.
*
* @param sort
* whether or not elements should be sorted
*/
protected void setSort(boolean sort) {
fSort = sort;
if (sort) {
if (fComparator == null) {
fComparator = new AntOutlineComparator();
}
getTreeViewer().setComparator(fComparator);
} else {
getTreeViewer().setComparator(null);
}
AntUIPlugin.getDefault().getPreferenceStore().setValue(IAntUIPreferenceConstants.ANTEDITOR_SORT, sort);
}
/**
* Returns whether elements are currently being sorted.
*
* @return whether elements are currently being sorted
*/
protected boolean isSort() {
return fSort;
}
/**
* Creates a new AntEditorContentOutlinePage.
*/
public AntEditorContentOutlinePage(AntModelCore core, AntEditor editor) {
super();
fCore = core;
fFilterInternalTargets = AntUIPlugin.getDefault().getPreferenceStore().getBoolean(IAntUIPreferenceConstants.ANTEDITOR_FILTER_INTERNAL_TARGETS);
fFilterImportedElements = AntUIPlugin.getDefault().getPreferenceStore().getBoolean(IAntUIPreferenceConstants.ANTEDITOR_FILTER_IMPORTED_ELEMENTS);
fFilterProperties = AntUIPlugin.getDefault().getPreferenceStore().getBoolean(IAntUIPreferenceConstants.ANTEDITOR_FILTER_PROPERTIES);
fFilterTopLevel = AntUIPlugin.getDefault().getPreferenceStore().getBoolean(IAntUIPreferenceConstants.ANTEDITOR_FILTER_TOP_LEVEL);
fSort = AntUIPlugin.getDefault().getPreferenceStore().getBoolean(IAntUIPreferenceConstants.ANTEDITOR_SORT);
fEditor = editor;
fTogglePresentation = new TogglePresentationAction();
fTogglePresentation.setEditor(editor);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.part.IPage#dispose()
*/
@Override
public void dispose() {
if (fMenu != null) {
fMenu.dispose();
}
if (fOpenWithMenu != null) {
fOpenWithMenu.dispose();
}
if (fListener != null) {
fCore.removeAntModelListener(fListener);
fListener = null;
}
fTogglePresentation.setEditor(null);
super.dispose();
}
/**
* Creates the control (outline view) for this page
*/
@Override
public void createControl(Composite parent) {
super.createControl(parent);
TreeViewer viewer = getTreeViewer();
viewer.setContentProvider(new AntModelContentProvider());
setSort(fSort);
viewer.setLabelProvider(new AntModelLabelProvider());
viewer.addFilter(new AntOutlineFilter());
if (fModel != null) {
setViewerInput(fModel);
}
MenuManager manager = new MenuManager("#PopUp"); //$NON-NLS-1$
manager.setRemoveAllWhenShown(true);
manager.addMenuListener(new IMenuListener() {
@Override
public void menuAboutToShow(IMenuManager menuManager) {
contextMenuAboutToShow(menuManager);
}
});
fMenu = manager.createContextMenu(viewer.getTree());
viewer.getTree().setMenu(fMenu);
IPageSite site = getSite();
site.registerContextMenu(IAntUIConstants.PLUGIN_ID + ".antEditorOutline", manager, viewer); //$NON-NLS-1$
IToolBarManager tbm = site.getActionBars().getToolBarManager();
tbm.add(new ToggleSortAntOutlineAction(this));
tbm.add(new FilterInternalTargetsAction(this));
tbm.add(new FilterPropertiesAction(this));
tbm.add(new FilterImportedElementsAction(this));
tbm.add(new FilterTopLevelAction(this));
IMenuManager viewMenu = site.getActionBars().getMenuManager();
viewMenu.add(new ToggleLinkWithEditorAction(fEditor));
fOpenWithMenu = new AntOpenWithMenu(this.getSite().getPage());
viewer.addPostSelectionChangedListener(new ISelectionChangedListener() {
@Override
public void selectionChanged(SelectionChangedEvent event) {
firePostSelectionChanged(event.getSelection());
}
});
site.getActionBars().setGlobalActionHandler(ITextEditorActionDefinitionIds.TOGGLE_SHOW_SELECTED_ELEMENT_ONLY, fTogglePresentation);
}
private void setViewerInput(Object newInput) {
TreeViewer tree = getTreeViewer();
Object oldInput = tree.getInput();
boolean isAntModel = (newInput instanceof AntModel);
boolean wasAntModel = (oldInput instanceof AntModel);
if (isAntModel && !wasAntModel) {
if (fListener == null) {
fListener = createAntModelChangeListener();
}
fCore.addAntModelListener(fListener);
} else if (!isAntModel && wasAntModel && fListener != null) {
fCore.removeAntModelListener(fListener);
fListener = null;
}
tree.setInput(newInput);
if (isAntModel) {
updateTreeExpansion();
}
}
public void setPageInput(AntModel xmlModel) {
fModel = xmlModel;
if (getTreeViewer() != null) {
setViewerInput(fModel);
}
}
private IAntModelListener createAntModelChangeListener() {
return new IAntModelListener() {
@Override
public void antModelChanged(final AntModelChangeEvent event) {
if (event.getModel() == fModel && !getControl().isDisposed()) {
getControl().getDisplay().asyncExec(new Runnable() {
@Override
public void run() {
Control ctrl = getControl();
if (ctrl != null && !ctrl.isDisposed()) {
getTreeViewer().refresh();
updateTreeExpansion();
}
}
});
}
}
};
}
public void addPostSelectionChangedListener(ISelectionChangedListener listener) {
fPostSelectionChangedListeners.add(listener);
}
public void removePostSelectionChangedListener(ISelectionChangedListener listener) {
fPostSelectionChangedListeners.remove(listener);
}
private void updateTreeExpansion() {
boolean wasModelEmpty = fIsModelEmpty;
fIsModelEmpty = fModel == null || fModel.getProjectNode() == null;
if (wasModelEmpty && !fIsModelEmpty) {
getTreeViewer().expandToLevel(EXPAND_TO_LEVEL);
}
}
private void firePostSelectionChanged(ISelection selection) {
// create an event
SelectionChangedEvent event = new SelectionChangedEvent(this, selection);
// fire the event
for (ISelectionChangedListener iSelectionChangedListener : fPostSelectionChangedListeners) {
iSelectionChangedListener.selectionChanged(event);
}
}
private void contextMenuAboutToShow(IMenuManager menuManager) {
if (shouldAddOpenWithMenu()) {
addOpenWithMenu(menuManager);
}
menuManager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
}
private void addOpenWithMenu(IMenuManager menuManager) {
AntElementNode element = getSelectedNode();
IFile file = null;
if (element != null) {
file = element.getIFile();
}
if (file != null) {
menuManager.add(new Separator("group.open")); //$NON-NLS-1$
IMenuManager submenu = new MenuManager(AntOutlineMessages.AntEditorContentOutlinePage_Open_With_1);
fOpenWithMenu.setNode(element);
submenu.add(fOpenWithMenu);
menuManager.appendToGroup("group.open", submenu); //$NON-NLS-1$
}
}
private boolean shouldAddOpenWithMenu() {
AntElementNode node = getSelectedNode();
if (node instanceof AntImportNode) {
return true;
}
if (node != null && node.isExternal()) {
String path = node.getFilePath();
if (path != null && path.length() > 0) {
return true;
}
}
return false;
}
private AntElementNode getSelectedNode() {
ISelection iselection = getSelection();
if (iselection instanceof IStructuredSelection) {
IStructuredSelection selection = (IStructuredSelection) iselection;
if (selection.size() == 1) {
Object selected = selection.getFirstElement();
if (selected instanceof AntElementNode) {
return (AntElementNode) selected;
}
}
}
return null;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.core.runtime.IAdaptable#getAdapter(java.lang.Class)
*/
@SuppressWarnings("unchecked")
@Override
public <T> T getAdapter(Class<T> key) {
if (key == IShowInSource.class) {
return (T) this;
}
return null;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.part.IShowInSource#getShowInContext()
*/
@Override
public ShowInContext getShowInContext() {
IFile file = null;
if (fModel != null) {
AntElementNode node = getSelectedNode();
if (node != null) {
file = node.getIFile();
}
}
if (file != null) {
ISelection selection = new StructuredSelection(file);
return new ShowInContext(null, selection);
}
return null;
}
public void select(AntElementNode node) {
if (getTreeViewer() != null) {
ISelection s = getTreeViewer().getSelection();
if (s instanceof IStructuredSelection) {
IStructuredSelection ss = (IStructuredSelection) s;
List<?> nodes = ss.toList();
if (!nodes.contains(node)) {
s = (node == null ? StructuredSelection.EMPTY : new StructuredSelection(node));
getTreeViewer().setSelection(s, true);
}
}
}
}
}